// pages/detail/detail.js
const galleryApi = require('../../api/galleryApi');
// 我们不再使用HTTP API，因此移除userApi导入
// const userApi = require('../../api/userApi');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    imageId: '',
    image: null,
    loading: true,
    isAuthor: false,
    isLiked: false,
    isFavorited: false,
    comment: '',
    comments: [],
    commentsLoading: false,
    commentsPage: 1,
    hasMoreComments: true,
    imageError: false, // 添加图片加载错误标记
    tempImageUrl: '', // 新增临时图片URL存储
    retryCount: 0, // 新增重试计数
    submittingComment: false // 新增评论提交状态
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 隐藏小程序默认导航栏
    wx.hideHomeButton();
    
    // 检查云环境
    const app = getApp();
    if (!wx.cloud) {
      wx.showToast({
        title: '请使用较新版本的微信',
        icon: 'none'
      });
      return;
    }
    
    // 确保云环境已初始化
    if (!app.globalData.cloudEnvId) {
      console.error('云环境ID未配置');
      wx.showToast({
        title: '应用配置异常',
        icon: 'none'
      });
      return;
    }
    
    const imageId = options.id;
    if (!imageId) {
      wx.showToast({
        title: '参数错误',
        icon: 'error'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      return;
    }

    this.setData({ imageId });
    this.loadImageDetail();
    this.loadComments();
  },

  // 导航栏返回按钮点击事件处理
  onClickLeft() {
    wx.navigateBack({
      delta: 1
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    // 下拉刷新重新加载数据
    this.loadImageDetail();
    this.loadComments();
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    // 滚动到底部加载更多评论
    if (this.data.hasMoreComments && !this.data.commentsLoading) {
      this.loadMoreComments();
    }
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function() {
    const { image } = this.data;
    const imageUrl = this.data.tempImageUrl || image?.imageUrl;
    
    // 生成更吸引人的分享标题
    let title = '看看我发现的惊艳图片！';
    if (image?.title) {
      title = `【${image.title}】- ${image.author?.nickName || '创作者'}的精彩作品`;
    }
    
    console.log('分享图片:', {
      title: title,
      path: `/pages/detail/detail?id=${this.data.imageId}`,
      imageUrl: imageUrl
    });
    
    return {
      title: title,
      path: `/pages/detail/detail?id=${this.data.imageId}`,
      imageUrl: imageUrl,
      success: function(res) {
        wx.showToast({
          title: '分享成功',
          icon: 'success'
        });
      },
      fail: function(res) {
        console.error('分享失败:', res);
      }
    }
  },

  // 加载图片详情
  loadImageDetail: function() {
    this.setData({ 
      loading: true, 
      imageError: false,
      retryCount: 0 // 重置重试计数
    });
    
    console.log('正在加载图片，ID:', this.data.imageId);

    galleryApi.getImageDetail(this.data.imageId)
      .then(res => {
        if (res.data && res.data.image) {
          const image = res.data.image;
          const userInfo = getApp().globalData.userInfo || {};
          
          console.log('获取到图片数据:', image);
          
          // 确保图片URL正确
          if (image.imageUrl || image.fileID) {
            // 优先使用imageUrl，如果没有则尝试使用fileID
            const imageSource = image.imageUrl || image.fileID;
            
            if (imageSource.indexOf('cloud://') === 0) {
              // 如果是云存储路径，需要通过云文件ID获取临时链接
              console.log('检测到云存储路径，正在获取临时链接');
              this.getImageTempUrl(imageSource);
            } else {
              // 如果是普通URL，直接设置
              console.log('使用普通URL:', imageSource);
              this.setData({
                tempImageUrl: imageSource,
                loading: false
              });
            }
          } else {
            console.error('图片URL和fileID均为空');
            this.setData({ 
              imageError: true,
              loading: false 
            });
            
            wx.showToast({
              title: '图片信息不完整',
              icon: 'none'
            });
          }
          
          this.setData({
            image: image,
            isAuthor: image.author.id === userInfo.id,
            isLiked: image.isLiked || false,
            isFavorited: image.isFavorited || false,
            loading: image.imageUrl ? false : this.data.loading // 只有在没有URL的情况下保持loading状态
          });
        } else {
          console.error('返回数据格式异常:', res);
          throw new Error('加载详情失败');
        }
      })
      .catch(err => {
        console.error('加载图片详情失败', err);
        this.setData({ 
          loading: false, 
          imageError: true 
        });
        
        wx.showToast({
          title: '图片详情加载失败',
          icon: 'none'
        });
      });
  },
  
  // 处理云存储图片，获取临时访问链接
  getImageTempUrl: function(cloudFileId) {
    console.log('获取临时文件URL，云文件ID:', cloudFileId);
    
    // 检查云文件ID格式
    if (!cloudFileId || typeof cloudFileId !== 'string' || cloudFileId.indexOf('cloud://') !== 0) {
      console.error('无效的云文件ID:', cloudFileId);
      this.setData({
        imageError: true,
        loading: false
      });
      wx.showToast({
        title: '图片路径无效',
        icon: 'none'
      });
      return;
    }
    
    wx.cloud.getTempFileURL({
      fileList: [cloudFileId],
      success: res => {
        console.log('获取临时文件URL成功:', res);
        if (res.fileList && res.fileList.length > 0) {
          const tempUrl = res.fileList[0].tempFileURL;
          if (tempUrl) {
            console.log('临时URL:', tempUrl);
            this.setData({
              'image.imageUrl': tempUrl,
              tempImageUrl: tempUrl,
              imageError: false,
              loading: false
            });
            
            // 预加载图片，验证链接是否有效
            wx.getImageInfo({
              src: tempUrl,
              success: () => {
                console.log('图片预加载成功');
              },
              fail: imgErr => {
                console.error('图片链接无效:', imgErr);
                this.setData({ imageError: true });
              }
            });
          } else {
            console.error('临时URL为空');
            this.setData({
              imageError: true,
              loading: false
            });
          }
        } else {
          console.error('获取临时文件URL成功，但返回结果为空');
          this.setData({
            imageError: true,
            loading: false
          });
        }
      },
      fail: err => {
        console.error('获取临时文件URL失败:', err);
        // 尝试使用完整的文件ID路径
        const fullPath = cloudFileId;
        console.log('尝试使用完整路径:', fullPath);
        
        this.setData({
          'image.imageUrl': fullPath,
          tempImageUrl: fullPath,
          imageError: true,
          loading: false
        });
        
        wx.showToast({
          title: '获取图片链接失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 图片加载错误处理
  onImageError: function(e) {
    console.error('图片加载失败', e);
    
    // 设置加载错误状态
    this.setData({
      imageError: true,
      loading: false
    });
    
    // 如果已经重试了超过3次，就停止尝试
    if (this.data.retryCount >= 3) {
      console.log('已重试多次，停止尝试');
      wx.showToast({
        title: '图片加载失败，请稍后再试',
        icon: 'none'
      });
      return;
    }
    
    // 尝试重新加载图片
    if (this.data.image && this.data.image.imageUrl) {
      console.log('尝试重新加载图片:', this.data.image.imageUrl);
      
      // 增加重试计数
      this.setData({
        retryCount: (this.data.retryCount || 0) + 1
      });
      
      // 检查URL类型
      if (this.data.image.imageUrl.indexOf('cloud://') === 0) {
        console.log('尝试重新获取云存储临时链接');
        this.getImageTempUrl(this.data.image.imageUrl);
      } else if (this.data.image.fileID && this.data.image.fileID.indexOf('cloud://') === 0) {
        // 如果imageUrl失败，尝试使用fileID
        console.log('尝试使用fileID获取临时链接:', this.data.image.fileID);
        this.getImageTempUrl(this.data.image.fileID);
      } else {
        // 如果不是云存储路径但加载失败，可能是临时链接过期或网络问题
        console.log('非云存储路径加载失败，延时重新请求详情');
        setTimeout(() => {
          this.loadImageDetail();
        }, 1500);
      }
    } else {
      console.error('无有效图片URL可重试');
    }
  },
  
  // 图片加载成功处理
  onImageLoad: function() {
    console.log('图片加载成功');
    this.setData({
      imageError: false,
      loading: false
    });
  },

  // 加载评论
  loadComments: function() {
    if (this.data.commentsLoading) return;

    this.setData({ commentsLoading: true });

    // 直接调用云函数加载评论
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: 'getComments',
        params: {
          imageId: this.data.imageId,
          page: 1,
          limit: 20
        }
      },
      success: res => {
        console.log('评论加载响应:', res.result);
        
        if (res.result && res.result.success && res.result.data) {
          // 格式化评论时间
          const comments = (res.result.data.comments || []).map(comment => {
            return {
              ...comment,
              createTime: this.formatCommentTime(comment.createTime)
            };
          });
          
          this.setData({
            comments: comments,
            commentsPage: 1,
            hasMoreComments: res.result.data.hasMore || false,
            commentsLoading: false
          });
        } else {
          this.setData({ 
            commentsLoading: false,
            comments: []
          });
          
          console.error('加载评论失败:', res.result ? res.result.message : '未知错误');
        }
      },
      fail: err => {
        console.error('加载评论失败', err);
        this.setData({ 
          commentsLoading: false,
          comments: []
        });
      }
    });
  },

  // 加载更多评论
  loadMoreComments: function() {
    if (this.data.commentsLoading || !this.data.hasMoreComments) return;

    this.setData({ commentsLoading: true });

    // 直接调用云函数加载更多评论
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: 'getComments',
        params: {
          imageId: this.data.imageId,
          page: this.data.commentsPage + 1,
          limit: 20
        }
      },
      success: res => {
        console.log('加载更多评论响应:', res.result);
        
        if (res.result && res.result.success && res.result.data) {
          // 格式化评论时间
          const newComments = (res.result.data.comments || []).map(comment => {
            return {
              ...comment,
              createTime: this.formatCommentTime(comment.createTime)
            };
          });
          
          this.setData({
            comments: [...this.data.comments, ...newComments],
            commentsPage: this.data.commentsPage + 1,
            hasMoreComments: res.result.data.hasMore || false,
            commentsLoading: false
          });
        } else {
          this.setData({ 
            commentsLoading: false,
            hasMoreComments: false
          });
          
          console.error('加载更多评论失败:', res.result ? res.result.message : '未知错误');
        }
      },
      fail: err => {
        console.error('加载更多评论失败', err);
        this.setData({ 
          commentsLoading: false 
        });
      }
    });
  },
  
  // 格式化评论时间为友好显示
  formatCommentTime: function(timestamp) {
    if (!timestamp) return '';
    
    // 如果是字符串日期，直接返回
    if (typeof timestamp === 'string') {
      return timestamp;
    }
    
    try {
      const commentDate = new Date(timestamp);
      const now = new Date();
      const diffMs = now - commentDate;
      const diffSec = Math.floor(diffMs / 1000);
      
      if (diffSec < 60) {
        return '刚刚';
      } else if (diffSec < 3600) {
        return Math.floor(diffSec / 60) + '分钟前';
      } else if (diffSec < 86400) {
        return Math.floor(diffSec / 3600) + '小时前';
      } else if (diffSec < 604800) {
        return Math.floor(diffSec / 86400) + '天前';
      } else {
        // 格式化日期: 年-月-日 时:分
        const year = commentDate.getFullYear();
        const month = (commentDate.getMonth() + 1).toString().padStart(2, '0');
        const day = commentDate.getDate().toString().padStart(2, '0');
        const hour = commentDate.getHours().toString().padStart(2, '0');
        const minute = commentDate.getMinutes().toString().padStart(2, '0');
        
        return `${year}-${month}-${day} ${hour}:${minute}`;
      }
    } catch (e) {
      console.error('格式化时间错误:', e);
      return timestamp.toString();
    }
  },

  // 输入评论
  onCommentInput: function(e) {
    this.setData({
      comment: e.detail.value
    });
  },

  // 提交评论
  submitComment: function() {
    if (!this.data.comment.trim()) {
      wx.showToast({
        title: '请输入评论内容',
        icon: 'none'
      });
      return;
    }
    
    // 设置提交状态
    this.setData({ submittingComment: true });

    // 显示加载提示
    wx.showLoading({
      title: '提交评论中...',
      mask: true
    });
    
    // 直接调用云函数提交评论
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: 'addComment',
        params: {
          imageId: this.data.imageId,
          content: this.data.comment
        }
      },
      success: res => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.log('评论提交响应:', res.result);
        
        if (res.result && res.result.success) {
          // 重新加载评论
          this.loadComments();
          this.setData({ 
            comment: '',
            submittingComment: false 
          });
          
          // 显示成功提示
          wx.showToast({
            title: '评论成功',
            icon: 'success'
          });
          
          // 更新评论数量（如果需要）
          if (this.data.image) {
            this.setData({
              'image.commentCount': (this.data.image.commentCount || 0) + 1
            });
          }
        } else {
          this.setData({ submittingComment: false });
          // 显示错误信息
          wx.showToast({
            title: res.result ? res.result.message || '评论失败' : '评论失败',
            icon: 'none'
          });
        }
      },
      fail: err => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.error('提交评论失败', err);
        this.setData({ submittingComment: false });
        
        wx.showToast({
          title: '评论失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 点赞
  handleLike: function() {
    if (!this.data.image) return;

    const isLiked = !this.data.isLiked;
    const likeCount = isLiked 
      ? (this.data.image.likeCount || 0) + 1 
      : (this.data.image.likeCount || 0) - 1;

    // 乐观更新UI
    this.setData({
      isLiked: isLiked,
      'image.likeCount': likeCount
    });

    // 显示加载提示
    wx.showLoading({
      title: isLiked ? '点赞中...' : '取消点赞中...',
      mask: true
    });
    
    // 调用云函数点赞/取消点赞
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: isLiked ? 'likeImage' : 'unlikeImage',
        params: {
          imageId: this.data.imageId
        }
      },
      success: res => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.log('点赞操作响应:', res.result);
        
        if (!res.result || !res.result.success) {
          // 如果失败则回滚UI
          this.setData({
            isLiked: !isLiked,
            'image.likeCount': isLiked ? likeCount - 1 : likeCount + 1
          });
          
          // 显示错误信息
          wx.showToast({
            title: res.result ? res.result.message || '操作失败' : '操作失败',
            icon: 'none'
          });
        } else {
          // 操作成功，设置刷新标志以确保所有页面状态一致
          const app = getApp();
          app.globalData.galleryNeedRefresh = true;
          
          // 显示成功提示
          wx.showToast({
            title: isLiked ? '点赞成功' : '已取消点赞',
            icon: 'success'
          });
        }
      },
      fail: err => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.error('点赞操作失败', err);
        // 失败则回滚UI
        this.setData({
          isLiked: !isLiked,
          'image.likeCount': isLiked ? likeCount - 1 : likeCount + 1
        });
        
        wx.showToast({
          title: '操作失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 收藏
  handleFavorite: function() {
    if (!this.data.image) return;

    const isFavorited = !this.data.isFavorited;
    const favoriteCount = isFavorited 
      ? (this.data.image.favoriteCount || 0) + 1 
      : (this.data.image.favoriteCount || 0) - 1;

    // 乐观更新UI
    this.setData({
      isFavorited: isFavorited,
      'image.favoriteCount': favoriteCount
    });

    // 显示加载提示
    wx.showLoading({
      title: isFavorited ? '收藏中...' : '取消收藏中...',
      mask: true
    });
    
    // 调用云函数收藏/取消收藏
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: 'favoriteImage',
        params: {
          imageId: this.data.imageId
        }
      },
      success: res => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.log('收藏操作响应:', res.result);
        
        if (!res.result || !res.result.success) {
          // 如果失败则回滚UI
          this.setData({
            isFavorited: !isFavorited,
            'image.favoriteCount': isFavorited ? favoriteCount - 1 : favoriteCount + 1
          });
          
          // 显示错误信息
          wx.showToast({
            title: res.result ? res.result.message || '操作失败' : '操作失败',
            icon: 'none'
          });
        } else {
          // 操作成功，设置刷新标志以确保所有页面状态一致
          const app = getApp();
          app.globalData.galleryNeedRefresh = true;
          
          // 设置个人页面统计数据需要更新的标志
          app.globalData.userStatsNeedRefresh = true;
          wx.setStorageSync('userStatsNeedRefresh', true);
          
          // 显示成功提示
          wx.showToast({
            title: isFavorited ? '收藏成功' : '已取消收藏',
            icon: 'success'
          });
        }
      },
      fail: err => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.error('收藏操作失败', err);
        // 失败则回滚UI
        this.setData({
          isFavorited: !isFavorited,
          'image.favoriteCount': isFavorited ? favoriteCount - 1 : favoriteCount + 1
        });
        
        wx.showToast({
          title: '操作失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 关注作者
  followAuthor: function() {
    if (!this.data.image || !this.data.image.author) return;

    wx.showToast({
      title: '关注成功',
      icon: 'success'
    });
  },

  // 保存图片
  saveImage: function() {
    const imageUrl = this.data.tempImageUrl || this.data.image?.imageUrl;
    if (!imageUrl) {
      wx.showToast({
        title: '图片未加载完成',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '保存中...',
    });

    wx.downloadFile({
      url: imageUrl,
      success: (res) => {
        console.log('下载图片成功:', res);
        if (res.statusCode === 200) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              wx.hideLoading();
              wx.showToast({
                title: '保存成功',
                icon: 'success'
              });
            },
            fail: (err) => {
              wx.hideLoading();
              console.error('保存图片失败', err);
              wx.showToast({
                title: '保存失败',
                icon: 'none'
              });
            }
          });
        } else {
          wx.hideLoading();
          wx.showToast({
            title: '下载失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('下载图片失败:', err);
        wx.hideLoading();
        wx.showToast({
          title: '下载失败',
          icon: 'none'
        });
      }
    });
  },

  // 预览图片
  previewImage: function() {
    const imageUrl = this.data.tempImageUrl || this.data.image?.imageUrl;
    if (!imageUrl) {
      wx.showToast({
        title: '图片未加载完成',
        icon: 'none'
      });
      return;
    }

    wx.previewImage({
      urls: [imageUrl],
      current: imageUrl
    });
  }
})